/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_pooling_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "sycldnn/pooling/operators.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/pooling/pooling_fixture.h"

#include <array>
#include <vector>

using namespace sycldnn;  // NOLINT(google-build-using-namespace)
using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using MaxWindow5Stride1Forward =
    PoolingFixture<typename Pair::FirstType, typename Pair::SecondType,
                   pooling::Max, pooling::Forward>;
TYPED_TEST_SUITE(MaxWindow5Stride1Forward, GTestTypePairs);
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 16., 17., 18., 18., 18., 21., 22., 23., 24., 24., 24.,
      27., 28., 29., 30., 30., 30., 33., 34., 35., 36., 36., 36.,
      33., 34., 35., 36., 36., 36., 33., 34., 35., 36., 36., 36.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29., 30., 35., 36.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29., 30., 31., 32., 33., 34., 35., 36., 35., 36., 35., 36., 41., 42., 43.,
      44., 45., 46., 47., 48., 47., 48., 47., 48., 53., 54., 55., 56., 57., 58.,
      59., 60., 59., 60., 59., 60., 65., 66., 67., 68., 69., 70., 71., 72., 71.,
      72., 71., 72., 65., 66., 67., 68., 69., 70., 71., 72., 71., 72., 71., 72.,
      65., 66., 67., 68., 69., 70., 71., 72., 71., 72., 71., 72.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57., 58., 59., 60.,
                                         69., 70., 71., 72.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,
      81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,
      105., 106., 107., 108., 109., 110., 111., 112., 113., 114., 115., 116.,
      117., 118., 119., 120., 117., 118., 119., 120., 117., 118., 119., 120.,
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {113., 114., 115., 116., 117., 118.,
                                         119., 120., 137., 138., 139., 140.,
                                         141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x6x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17., 18., 19., 20., 21., 21., 21., 24., 25., 26., 27., 28., 28., 28.,
      31., 32., 33., 34., 35., 35., 35., 38., 39., 40., 41., 42., 42., 42.,
      38., 39., 40., 41., 42., 42., 42., 38., 39., 40., 41., 42., 42., 42.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x6x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33., 34., 35., 40., 41., 42.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x6x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 41., 42., 41., 42.,
      47., 48., 49., 50., 51., 52., 53., 54., 55., 56., 55., 56., 55., 56.,
      61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 69., 70., 69., 70.,
      75., 76., 77., 78., 79., 80., 81., 82., 83., 84., 83., 84., 83., 84.,
      75., 76., 77., 78., 79., 80., 81., 82., 83., 84., 83., 84., 83., 84.,
      75., 76., 77., 78., 79., 80., 81., 82., 83., 84., 83., 84., 83., 84.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x6x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {65., 66., 67., 68., 69., 70.,
                                         79., 80., 81., 82., 83., 84.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x6x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  81.,  82.,  83.,  84.,
      81.,  82.,  83.,  84.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      109., 110., 111., 112., 109., 110., 111., 112., 121., 122., 123., 124.,
      125., 126., 127., 128., 129., 130., 131., 132., 133., 134., 135., 136.,
      137., 138., 139., 140., 137., 138., 139., 140., 137., 138., 139., 140.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.,
      161., 162., 163., 164., 165., 166., 167., 168., 165., 166., 167., 168.,
      165., 166., 167., 168., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      165., 166., 167., 168., 165., 166., 167., 168., 149., 150., 151., 152.,
      153., 154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 165., 166., 167., 168., 165., 166., 167., 168.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x6x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x6x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19., 20., 21., 22., 23., 24., 24., 24., 27., 28., 29., 30.,
      31., 32., 32., 32., 35., 36., 37., 38., 39., 40., 40., 40.,
      43., 44., 45., 46., 47., 48., 48., 48., 43., 44., 45., 46.,
      47., 48., 48., 48., 43., 44., 45., 46., 47., 48., 48., 48.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x6x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 38., 39., 40.,
                                         45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x6x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48., 47., 48.,
      47., 48., 53., 54., 55., 56., 57., 58., 59., 60., 61., 62., 63., 64.,
      63., 64., 63., 64., 69., 70., 71., 72., 73., 74., 75., 76., 77., 78.,
      79., 80., 79., 80., 79., 80., 85., 86., 87., 88., 89., 90., 91., 92.,
      93., 94., 95., 96., 95., 96., 95., 96., 85., 86., 87., 88., 89., 90.,
      91., 92., 93., 94., 95., 96., 95., 96., 95., 96., 85., 86., 87., 88.,
      89., 90., 91., 92., 93., 94., 95., 96., 95., 96., 95., 96.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x6x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73., 74., 75., 76., 77., 78.,
                                         79., 80., 89., 90., 91., 92.,
                                         93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x6x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 125., 126., 127., 128.,
      125., 126., 127., 128., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      189., 190., 191., 192., 189., 190., 191., 192., 169., 170., 171., 172.,
      173., 174., 175., 176., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 189., 190., 191., 192.,
      189., 190., 191., 192., 169., 170., 171., 172., 173., 174., 175., 176.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x6x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155.,
      156., 157., 158., 159., 160., 177., 178., 179., 180., 181., 182.,
      183., 184., 185., 186., 187., 188., 189., 190., 191., 192.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x7x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 16., 17., 18., 18., 18., 21., 22., 23., 24., 24., 24., 27., 28.,
      29., 30., 30., 30., 33., 34., 35., 36., 36., 36., 39., 40., 41., 42.,
      42., 42., 39., 40., 41., 42., 42., 42., 39., 40., 41., 42., 42., 42.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x7x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29., 30., 35., 36., 41., 42.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x7x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29., 30., 31., 32., 33., 34., 35., 36., 35., 36., 35., 36., 41., 42.,
      43., 44., 45., 46., 47., 48., 47., 48., 47., 48., 53., 54., 55., 56.,
      57., 58., 59., 60., 59., 60., 59., 60., 65., 66., 67., 68., 69., 70.,
      71., 72., 71., 72., 71., 72., 77., 78., 79., 80., 81., 82., 83., 84.,
      83., 84., 83., 84., 77., 78., 79., 80., 81., 82., 83., 84., 83., 84.,
      83., 84., 77., 78., 79., 80., 81., 82., 83., 84., 83., 84., 83., 84.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x7x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57., 58., 59., 60., 69., 70.,
                                         71., 72., 81., 82., 83., 84.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x7x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,
      81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,
      105., 106., 107., 108., 109., 110., 111., 112., 113., 114., 115., 116.,
      117., 118., 119., 120., 117., 118., 119., 120., 117., 118., 119., 120.,
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      153., 154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 165., 166., 167., 168., 165., 166., 167., 168.,
      153., 154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 165., 166., 167., 168., 165., 166., 167., 168.,
      153., 154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 165., 166., 167., 168., 165., 166., 167., 168.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x7x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      113., 114., 115., 116., 117., 118., 119., 120., 137., 138., 139., 140.,
      141., 142., 143., 144., 161., 162., 163., 164., 165., 166., 167., 168.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17., 18., 19., 20., 21., 21., 21., 24., 25., 26., 27., 28., 28.,
      28., 31., 32., 33., 34., 35., 35., 35., 38., 39., 40., 41., 42.,
      42., 42., 45., 46., 47., 48., 49., 49., 49., 45., 46., 47., 48.,
      49., 49., 49., 45., 46., 47., 48., 49., 49., 49.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33., 34., 35., 40., 41.,
                                         42., 47., 48., 49.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 41., 42., 41., 42.,
      47., 48., 49., 50., 51., 52., 53., 54., 55., 56., 55., 56., 55., 56.,
      61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 69., 70., 69., 70.,
      75., 76., 77., 78., 79., 80., 81., 82., 83., 84., 83., 84., 83., 84.,
      89., 90., 91., 92., 93., 94., 95., 96., 97., 98., 97., 98., 97., 98.,
      89., 90., 91., 92., 93., 94., 95., 96., 97., 98., 97., 98., 97., 98.,
      89., 90., 91., 92., 93., 94., 95., 96., 97., 98., 97., 98., 97., 98.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {65., 66., 67., 68., 69., 70.,
                                         79., 80., 81., 82., 83., 84.,
                                         93., 94., 95., 96., 97., 98.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  81.,  82.,  83.,  84.,
      81.,  82.,  83.,  84.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      109., 110., 111., 112., 109., 110., 111., 112., 121., 122., 123., 124.,
      125., 126., 127., 128., 129., 130., 131., 132., 133., 134., 135., 136.,
      137., 138., 139., 140., 137., 138., 139., 140., 137., 138., 139., 140.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.,
      161., 162., 163., 164., 165., 166., 167., 168., 165., 166., 167., 168.,
      165., 166., 167., 168., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 193., 194., 195., 196.,
      193., 194., 195., 196., 193., 194., 195., 196., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      193., 194., 195., 196., 193., 194., 195., 196., 193., 194., 195., 196.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 193., 194., 195., 196., 193., 194., 195., 196.,
      193., 194., 195., 196.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      185., 186., 187., 188., 189., 190., 191., 192., 193., 194., 195., 196.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19., 20., 21., 22., 23., 24., 24., 24., 27., 28., 29., 30., 31., 32.,
      32., 32., 35., 36., 37., 38., 39., 40., 40., 40., 43., 44., 45., 46.,
      47., 48., 48., 48., 51., 52., 53., 54., 55., 56., 56., 56., 51., 52.,
      53., 54., 55., 56., 56., 56., 51., 52., 53., 54., 55., 56., 56., 56.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 38., 39., 40., 45., 46.,
                                         47., 48., 53., 54., 55., 56.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      47.,  48.,  47.,  48.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  63.,  64.,  63.,  64.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  79.,  80.,  79.,  80.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      95.,  96.,  95.,  96.,  101., 102., 103., 104., 105., 106., 107., 108.,
      109., 110., 111., 112., 111., 112., 111., 112., 101., 102., 103., 104.,
      105., 106., 107., 108., 109., 110., 111., 112., 111., 112., 111., 112.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      111., 112., 111., 112.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73., 74., 75., 76., 77.,  78.,  79.,  80.,  89.,  90.,  91.,  92.,
      93., 94., 95., 96., 105., 106., 107., 108., 109., 110., 111., 112.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 125., 126., 127., 128.,
      125., 126., 127., 128., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      189., 190., 191., 192., 189., 190., 191., 192., 201., 202., 203., 204.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 221., 222., 223., 224.,
      221., 222., 223., 224., 201., 202., 203., 204., 205., 206., 207., 208.,
      209., 210., 211., 212., 213., 214., 215., 216., 217., 218., 219., 220.,
      221., 222., 223., 224., 221., 222., 223., 224., 221., 222., 223., 224.,
      201., 202., 203., 204., 205., 206., 207., 208., 209., 210., 211., 212.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      221., 222., 223., 224., 221., 222., 223., 224.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 209., 210., 211., 212.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x8x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 16., 17., 18., 18., 18., 21., 22., 23., 24., 24., 24.,
      27., 28., 29., 30., 30., 30., 33., 34., 35., 36., 36., 36.,
      39., 40., 41., 42., 42., 42., 45., 46., 47., 48., 48., 48.,
      45., 46., 47., 48., 48., 48., 45., 46., 47., 48., 48., 48.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x8x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29., 30., 35., 36.,
                                         41., 42., 47., 48.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x8x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29., 30., 31., 32., 33., 34., 35., 36., 35., 36., 35., 36., 41., 42.,
      43., 44., 45., 46., 47., 48., 47., 48., 47., 48., 53., 54., 55., 56.,
      57., 58., 59., 60., 59., 60., 59., 60., 65., 66., 67., 68., 69., 70.,
      71., 72., 71., 72., 71., 72., 77., 78., 79., 80., 81., 82., 83., 84.,
      83., 84., 83., 84., 89., 90., 91., 92., 93., 94., 95., 96., 95., 96.,
      95., 96., 89., 90., 91., 92., 93., 94., 95., 96., 95., 96., 95., 96.,
      89., 90., 91., 92., 93., 94., 95., 96., 95., 96., 95., 96.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x8x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57., 58., 59., 60., 69., 70.,
                                         71., 72., 81., 82., 83., 84.,
                                         93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x8x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,
      81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,
      105., 106., 107., 108., 109., 110., 111., 112., 113., 114., 115., 116.,
      117., 118., 119., 120., 117., 118., 119., 120., 117., 118., 119., 120.,
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      153., 154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 165., 166., 167., 168., 165., 166., 167., 168.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x8x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      113., 114., 115., 116., 117., 118., 119., 120., 137., 138., 139.,
      140., 141., 142., 143., 144., 161., 162., 163., 164., 165., 166.,
      167., 168., 185., 186., 187., 188., 189., 190., 191., 192.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17., 18., 19., 20., 21., 21., 21., 24., 25., 26., 27., 28., 28., 28.,
      31., 32., 33., 34., 35., 35., 35., 38., 39., 40., 41., 42., 42., 42.,
      45., 46., 47., 48., 49., 49., 49., 52., 53., 54., 55., 56., 56., 56.,
      52., 53., 54., 55., 56., 56., 56., 52., 53., 54., 55., 56., 56., 56.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33., 34., 35., 40., 41., 42.,
                                         47., 48., 49., 54., 55., 56.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,  41.,  42.,  41.,  42.,
      41.,  42.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,
      55.,  56.,  55.,  56.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  69.,  70.,  69.,  70.,  75.,  76.,  77.,  78.,  79.,  80.,
      81.,  82.,  83.,  84.,  83.,  84.,  83.,  84.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  97.,  98.,  97.,  98.,  97.,  98.,  103., 104.,
      105., 106., 107., 108., 109., 110., 111., 112., 111., 112., 111., 112.,
      103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 111., 112.,
      111., 112., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      111., 112., 111., 112.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65., 66., 67., 68., 69., 70., 79.,  80.,  81.,  82.,  83.,  84.,
      93., 94., 95., 96., 97., 98., 107., 108., 109., 110., 111., 112.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  81.,  82.,  83.,  84.,
      81.,  82.,  83.,  84.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      109., 110., 111., 112., 109., 110., 111., 112., 121., 122., 123., 124.,
      125., 126., 127., 128., 129., 130., 131., 132., 133., 134., 135., 136.,
      137., 138., 139., 140., 137., 138., 139., 140., 137., 138., 139., 140.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.,
      161., 162., 163., 164., 165., 166., 167., 168., 165., 166., 167., 168.,
      165., 166., 167., 168., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 193., 194., 195., 196.,
      193., 194., 195., 196., 193., 194., 195., 196., 205., 206., 207., 208.,
      209., 210., 211., 212., 213., 214., 215., 216., 217., 218., 219., 220.,
      221., 222., 223., 224., 221., 222., 223., 224., 221., 222., 223., 224.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 221., 222., 223., 224.,
      221., 222., 223., 224., 205., 206., 207., 208., 209., 210., 211., 212.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      221., 222., 223., 224., 221., 222., 223., 224.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      185., 186., 187., 188., 189., 190., 191., 192., 193., 194., 195., 196.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19., 20., 21., 22., 23., 24., 24., 24., 27., 28., 29., 30., 31.,
      32., 32., 32., 35., 36., 37., 38., 39., 40., 40., 40., 43., 44.,
      45., 46., 47., 48., 48., 48., 51., 52., 53., 54., 55., 56., 56.,
      56., 59., 60., 61., 62., 63., 64., 64., 64., 59., 60., 61., 62.,
      63., 64., 64., 64., 59., 60., 61., 62., 63., 64., 64., 64.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 38., 39., 40., 45., 46.,
                                         47., 48., 53., 54., 55., 56.,
                                         61., 62., 63., 64.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      47.,  48.,  47.,  48.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  63.,  64.,  63.,  64.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  79.,  80.,  79.,  80.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      95.,  96.,  95.,  96.,  101., 102., 103., 104., 105., 106., 107., 108.,
      109., 110., 111., 112., 111., 112., 111., 112., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 127., 128., 127., 128.,
      117., 118., 119., 120., 121., 122., 123., 124., 125., 126., 127., 128.,
      127., 128., 127., 128., 117., 118., 119., 120., 121., 122., 123., 124.,
      125., 126., 127., 128., 127., 128., 127., 128.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  89.,  90.,  91.,
      92.,  93.,  94.,  95.,  96.,  105., 106., 107., 108., 109., 110.,
      111., 112., 121., 122., 123., 124., 125., 126., 127., 128.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 125., 126., 127., 128.,
      125., 126., 127., 128., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      189., 190., 191., 192., 189., 190., 191., 192., 201., 202., 203., 204.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 221., 222., 223., 224.,
      221., 222., 223., 224., 233., 234., 235., 236., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 253., 254., 255., 256., 253., 254., 255., 256.,
      233., 234., 235., 236., 237., 238., 239., 240., 241., 242., 243., 244.,
      245., 246., 247., 248., 249., 250., 251., 252., 253., 254., 255., 256.,
      253., 254., 255., 256., 253., 254., 255., 256., 233., 234., 235., 236.,
      237., 238., 239., 240., 241., 242., 243., 244., 245., 246., 247., 248.,
      249., 250., 251., 252., 253., 254., 255., 256., 253., 254., 255., 256.,
      253., 254., 255., 256.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155.,
      156., 157., 158., 159., 160., 177., 178., 179., 180., 181., 182.,
      183., 184., 185., 186., 187., 188., 189., 190., 191., 192., 209.,
      210., 211., 212., 213., 214., 215., 216., 217., 218., 219., 220.,
      221., 222., 223., 224., 241., 242., 243., 244., 245., 246., 247.,
      248., 249., 250., 251., 252., 253., 254., 255., 256.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15.,  16.,  17.,  18.,  18.,  18.,  21.,  22.,  23.,  24.,  24.,  24.,
      27.,  28.,  29.,  30.,  30.,  30.,  33.,  34.,  35.,  36.,  36.,  36.,
      33.,  34.,  35.,  36.,  36.,  36.,  33.,  34.,  35.,  36.,  36.,  36.,
      51.,  52.,  53.,  54.,  54.,  54.,  57.,  58.,  59.,  60.,  60.,  60.,
      63.,  64.,  65.,  66.,  66.,  66.,  69.,  70.,  71.,  72.,  72.,  72.,
      69.,  70.,  71.,  72.,  72.,  72.,  69.,  70.,  71.,  72.,  72.,  72.,
      87.,  88.,  89.,  90.,  90.,  90.,  93.,  94.,  95.,  96.,  96.,  96.,
      99.,  100., 101., 102., 102., 102., 105., 106., 107., 108., 108., 108.,
      105., 106., 107., 108., 108., 108., 105., 106., 107., 108., 108., 108.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29., 30., 35.,  36.,  65.,  66.,
                                         71., 72., 101., 102., 107., 108.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  35.,  36.,  35.,  36.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,  47.,  48.,
      53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  59.,  60.,  59.,  60.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,  71.,  72.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,  71.,  72.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,  71.,  72.,
      101., 102., 103., 104., 105., 106., 107., 108., 107., 108., 107., 108.,
      113., 114., 115., 116., 117., 118., 119., 120., 119., 120., 119., 120.,
      125., 126., 127., 128., 129., 130., 131., 132., 131., 132., 131., 132.,
      137., 138., 139., 140., 141., 142., 143., 144., 143., 144., 143., 144.,
      137., 138., 139., 140., 141., 142., 143., 144., 143., 144., 143., 144.,
      137., 138., 139., 140., 141., 142., 143., 144., 143., 144., 143., 144.,
      173., 174., 175., 176., 177., 178., 179., 180., 179., 180., 179., 180.,
      185., 186., 187., 188., 189., 190., 191., 192., 191., 192., 191., 192.,
      197., 198., 199., 200., 201., 202., 203., 204., 203., 204., 203., 204.,
      209., 210., 211., 212., 213., 214., 215., 216., 215., 216., 215., 216.,
      209., 210., 211., 212., 213., 214., 215., 216., 215., 216., 215., 216.,
      209., 210., 211., 212., 213., 214., 215., 216., 215., 216., 215., 216.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  69.,  70.,  71.,  72.,  129., 130., 131., 132.,
      141., 142., 143., 144., 201., 202., 203., 204., 213., 214., 215., 216.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,
      81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,
      105., 106., 107., 108., 109., 110., 111., 112., 113., 114., 115., 116.,
      117., 118., 119., 120., 117., 118., 119., 120., 117., 118., 119., 120.,
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      201., 202., 203., 204., 205., 206., 207., 208., 209., 210., 211., 212.,
      213., 214., 215., 216., 213., 214., 215., 216., 213., 214., 215., 216.,
      225., 226., 227., 228., 229., 230., 231., 232., 233., 234., 235., 236.,
      237., 238., 239., 240., 237., 238., 239., 240., 237., 238., 239., 240.,
      249., 250., 251., 252., 253., 254., 255., 256., 257., 258., 259., 260.,
      261., 262., 263., 264., 261., 262., 263., 264., 261., 262., 263., 264.,
      273., 274., 275., 276., 277., 278., 279., 280., 281., 282., 283., 284.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      273., 274., 275., 276., 277., 278., 279., 280., 281., 282., 283., 284.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      273., 274., 275., 276., 277., 278., 279., 280., 281., 282., 283., 284.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      345., 346., 347., 348., 349., 350., 351., 352., 353., 354., 355., 356.,
      357., 358., 359., 360., 357., 358., 359., 360., 357., 358., 359., 360.,
      369., 370., 371., 372., 373., 374., 375., 376., 377., 378., 379., 380.,
      381., 382., 383., 384., 381., 382., 383., 384., 381., 382., 383., 384.,
      393., 394., 395., 396., 397., 398., 399., 400., 401., 402., 403., 404.,
      405., 406., 407., 408., 405., 406., 407., 408., 405., 406., 407., 408.,
      417., 418., 419., 420., 421., 422., 423., 424., 425., 426., 427., 428.,
      429., 430., 431., 432., 429., 430., 431., 432., 429., 430., 431., 432.,
      417., 418., 419., 420., 421., 422., 423., 424., 425., 426., 427., 428.,
      429., 430., 431., 432., 429., 430., 431., 432., 429., 430., 431., 432.,
      417., 418., 419., 420., 421., 422., 423., 424., 425., 426., 427., 428.,
      429., 430., 431., 432., 429., 430., 431., 432., 429., 430., 431., 432.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      113., 114., 115., 116., 117., 118., 119., 120., 137., 138., 139., 140.,
      141., 142., 143., 144., 257., 258., 259., 260., 261., 262., 263., 264.,
      281., 282., 283., 284., 285., 286., 287., 288., 401., 402., 403., 404.,
      405., 406., 407., 408., 425., 426., 427., 428., 429., 430., 431., 432.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x6x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.,  18.,  19.,  20.,  21.,  21.,  21.,  24.,  25.,  26.,  27.,  28.,
      28.,  28.,  31.,  32.,  33.,  34.,  35.,  35.,  35.,  38.,  39.,  40.,
      41.,  42.,  42.,  42.,  38.,  39.,  40.,  41.,  42.,  42.,  42.,  38.,
      39.,  40.,  41.,  42.,  42.,  42.,  59.,  60.,  61.,  62.,  63.,  63.,
      63.,  66.,  67.,  68.,  69.,  70.,  70.,  70.,  73.,  74.,  75.,  76.,
      77.,  77.,  77.,  80.,  81.,  82.,  83.,  84.,  84.,  84.,  80.,  81.,
      82.,  83.,  84.,  84.,  84.,  80.,  81.,  82.,  83.,  84.,  84.,  84.,
      101., 102., 103., 104., 105., 105., 105., 108., 109., 110., 111., 112.,
      112., 112., 115., 116., 117., 118., 119., 119., 119., 122., 123., 124.,
      125., 126., 126., 126., 122., 123., 124., 125., 126., 126., 126., 122.,
      123., 124., 125., 126., 126., 126.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x6x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33.,  34.,  35.,  40.,  41.,  42.,
                                         75.,  76.,  77.,  82.,  83.,  84.,
                                         117., 118., 119., 124., 125., 126.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x6x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,  41.,  42.,  41.,  42.,
      41.,  42.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,
      55.,  56.,  55.,  56.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  69.,  70.,  69.,  70.,  75.,  76.,  77.,  78.,  79.,  80.,
      81.,  82.,  83.,  84.,  83.,  84.,  83.,  84.,  75.,  76.,  77.,  78.,
      79.,  80.,  81.,  82.,  83.,  84.,  83.,  84.,  83.,  84.,  75.,  76.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  83.,  84.,  83.,  84.,
      117., 118., 119., 120., 121., 122., 123., 124., 125., 126., 125., 126.,
      125., 126., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      139., 140., 139., 140., 145., 146., 147., 148., 149., 150., 151., 152.,
      153., 154., 153., 154., 153., 154., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 167., 168., 167., 168., 159., 160., 161., 162.,
      163., 164., 165., 166., 167., 168., 167., 168., 167., 168., 159., 160.,
      161., 162., 163., 164., 165., 166., 167., 168., 167., 168., 167., 168.,
      201., 202., 203., 204., 205., 206., 207., 208., 209., 210., 209., 210.,
      209., 210., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      223., 224., 223., 224., 229., 230., 231., 232., 233., 234., 235., 236.,
      237., 238., 237., 238., 237., 238., 243., 244., 245., 246., 247., 248.,
      249., 250., 251., 252., 251., 252., 251., 252., 243., 244., 245., 246.,
      247., 248., 249., 250., 251., 252., 251., 252., 251., 252., 243., 244.,
      245., 246., 247., 248., 249., 250., 251., 252., 251., 252., 251., 252.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x6x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  79.,  80.,  81.,  82.,  83.,  84.,
      149., 150., 151., 152., 153., 154., 163., 164., 165., 166., 167., 168.,
      233., 234., 235., 236., 237., 238., 247., 248., 249., 250., 251., 252.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x6x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  81.,  82.,  83.,  84.,
      81.,  82.,  83.,  84.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      109., 110., 111., 112., 109., 110., 111., 112., 121., 122., 123., 124.,
      125., 126., 127., 128., 129., 130., 131., 132., 133., 134., 135., 136.,
      137., 138., 139., 140., 137., 138., 139., 140., 137., 138., 139., 140.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.,
      161., 162., 163., 164., 165., 166., 167., 168., 165., 166., 167., 168.,
      165., 166., 167., 168., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      165., 166., 167., 168., 165., 166., 167., 168., 149., 150., 151., 152.,
      153., 154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 165., 166., 167., 168., 165., 166., 167., 168.,
      233., 234., 235., 236., 237., 238., 239., 240., 241., 242., 243., 244.,
      245., 246., 247., 248., 249., 250., 251., 252., 249., 250., 251., 252.,
      249., 250., 251., 252., 261., 262., 263., 264., 265., 266., 267., 268.,
      269., 270., 271., 272., 273., 274., 275., 276., 277., 278., 279., 280.,
      277., 278., 279., 280., 277., 278., 279., 280., 289., 290., 291., 292.,
      293., 294., 295., 296., 297., 298., 299., 300., 301., 302., 303., 304.,
      305., 306., 307., 308., 305., 306., 307., 308., 305., 306., 307., 308.,
      317., 318., 319., 320., 321., 322., 323., 324., 325., 326., 327., 328.,
      329., 330., 331., 332., 333., 334., 335., 336., 333., 334., 335., 336.,
      333., 334., 335., 336., 317., 318., 319., 320., 321., 322., 323., 324.,
      325., 326., 327., 328., 329., 330., 331., 332., 333., 334., 335., 336.,
      333., 334., 335., 336., 333., 334., 335., 336., 317., 318., 319., 320.,
      321., 322., 323., 324., 325., 326., 327., 328., 329., 330., 331., 332.,
      333., 334., 335., 336., 333., 334., 335., 336., 333., 334., 335., 336.,
      401., 402., 403., 404., 405., 406., 407., 408., 409., 410., 411., 412.,
      413., 414., 415., 416., 417., 418., 419., 420., 417., 418., 419., 420.,
      417., 418., 419., 420., 429., 430., 431., 432., 433., 434., 435., 436.,
      437., 438., 439., 440., 441., 442., 443., 444., 445., 446., 447., 448.,
      445., 446., 447., 448., 445., 446., 447., 448., 457., 458., 459., 460.,
      461., 462., 463., 464., 465., 466., 467., 468., 469., 470., 471., 472.,
      473., 474., 475., 476., 473., 474., 475., 476., 473., 474., 475., 476.,
      485., 486., 487., 488., 489., 490., 491., 492., 493., 494., 495., 496.,
      497., 498., 499., 500., 501., 502., 503., 504., 501., 502., 503., 504.,
      501., 502., 503., 504., 485., 486., 487., 488., 489., 490., 491., 492.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      501., 502., 503., 504., 501., 502., 503., 504., 485., 486., 487., 488.,
      489., 490., 491., 492., 493., 494., 495., 496., 497., 498., 499., 500.,
      501., 502., 503., 504., 501., 502., 503., 504., 501., 502., 503., 504.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x6x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307., 308.,
      325., 326., 327., 328., 329., 330., 331., 332., 333., 334., 335., 336.,
      465., 466., 467., 468., 469., 470., 471., 472., 473., 474., 475., 476.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x6x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19.,  20.,  21.,  22.,  23.,  24.,  24.,  24.,  27.,  28.,  29.,  30.,
      31.,  32.,  32.,  32.,  35.,  36.,  37.,  38.,  39.,  40.,  40.,  40.,
      43.,  44.,  45.,  46.,  47.,  48.,  48.,  48.,  43.,  44.,  45.,  46.,
      47.,  48.,  48.,  48.,  43.,  44.,  45.,  46.,  47.,  48.,  48.,  48.,
      67.,  68.,  69.,  70.,  71.,  72.,  72.,  72.,  75.,  76.,  77.,  78.,
      79.,  80.,  80.,  80.,  83.,  84.,  85.,  86.,  87.,  88.,  88.,  88.,
      91.,  92.,  93.,  94.,  95.,  96.,  96.,  96.,  91.,  92.,  93.,  94.,
      95.,  96.,  96.,  96.,  91.,  92.,  93.,  94.,  95.,  96.,  96.,  96.,
      115., 116., 117., 118., 119., 120., 120., 120., 123., 124., 125., 126.,
      127., 128., 128., 128., 131., 132., 133., 134., 135., 136., 136., 136.,
      139., 140., 141., 142., 143., 144., 144., 144., 139., 140., 141., 142.,
      143., 144., 144., 144., 139., 140., 141., 142., 143., 144., 144., 144.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x6x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37., 38., 39., 40., 45.,  46.,  47.,  48.,  85.,  86.,  87.,  88.,
      93., 94., 95., 96., 133., 134., 135., 136., 141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x6x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      47.,  48.,  47.,  48.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  63.,  64.,  63.,  64.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  79.,  80.,  79.,  80.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      95.,  96.,  95.,  96.,  85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  95.,  96.,  95.,  96.,  85.,  86.,  87.,  88.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,  95.,  96.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      143., 144., 143., 144., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 159., 160., 159., 160., 165., 166., 167., 168.,
      169., 170., 171., 172., 173., 174., 175., 176., 175., 176., 175., 176.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      191., 192., 191., 192., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 191., 192., 191., 192., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 191., 192., 191., 192.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      239., 240., 239., 240., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 255., 256., 255., 256., 261., 262., 263., 264.,
      265., 266., 267., 268., 269., 270., 271., 272., 271., 272., 271., 272.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      287., 288., 287., 288., 277., 278., 279., 280., 281., 282., 283., 284.,
      285., 286., 287., 288., 287., 288., 287., 288., 277., 278., 279., 280.,
      281., 282., 283., 284., 285., 286., 287., 288., 287., 288., 287., 288.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x6x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  169., 170., 171., 172., 173., 174., 175., 176.,
      185., 186., 187., 188., 189., 190., 191., 192., 265., 266., 267., 268.,
      269., 270., 271., 272., 281., 282., 283., 284., 285., 286., 287., 288.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x6x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 125., 126., 127., 128.,
      125., 126., 127., 128., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      189., 190., 191., 192., 189., 190., 191., 192., 169., 170., 171., 172.,
      173., 174., 175., 176., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 189., 190., 191., 192.,
      189., 190., 191., 192., 169., 170., 171., 172., 173., 174., 175., 176.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 297., 298., 299., 300.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 329., 330., 331., 332., 333., 334., 335., 336.,
      337., 338., 339., 340., 341., 342., 343., 344., 345., 346., 347., 348.,
      349., 350., 351., 352., 349., 350., 351., 352., 349., 350., 351., 352.,
      361., 362., 363., 364., 365., 366., 367., 368., 369., 370., 371., 372.,
      373., 374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,
      381., 382., 383., 384., 381., 382., 383., 384., 361., 362., 363., 364.,
      365., 366., 367., 368., 369., 370., 371., 372., 373., 374., 375., 376.,
      377., 378., 379., 380., 381., 382., 383., 384., 381., 382., 383., 384.,
      381., 382., 383., 384., 361., 362., 363., 364., 365., 366., 367., 368.,
      369., 370., 371., 372., 373., 374., 375., 376., 377., 378., 379., 380.,
      381., 382., 383., 384., 381., 382., 383., 384., 381., 382., 383., 384.,
      457., 458., 459., 460., 461., 462., 463., 464., 465., 466., 467., 468.,
      469., 470., 471., 472., 473., 474., 475., 476., 477., 478., 479., 480.,
      477., 478., 479., 480., 477., 478., 479., 480., 489., 490., 491., 492.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      505., 506., 507., 508., 509., 510., 511., 512., 509., 510., 511., 512.,
      509., 510., 511., 512., 521., 522., 523., 524., 525., 526., 527., 528.,
      529., 530., 531., 532., 533., 534., 535., 536., 537., 538., 539., 540.,
      541., 542., 543., 544., 541., 542., 543., 544., 541., 542., 543., 544.,
      553., 554., 555., 556., 557., 558., 559., 560., 561., 562., 563., 564.,
      565., 566., 567., 568., 569., 570., 571., 572., 573., 574., 575., 576.,
      573., 574., 575., 576., 573., 574., 575., 576., 553., 554., 555., 556.,
      557., 558., 559., 560., 561., 562., 563., 564., 565., 566., 567., 568.,
      569., 570., 571., 572., 573., 574., 575., 576., 573., 574., 575., 576.,
      573., 574., 575., 576., 553., 554., 555., 556., 557., 558., 559., 560.,
      561., 562., 563., 564., 565., 566., 567., 568., 569., 570., 571., 572.,
      573., 574., 575., 576., 573., 574., 575., 576., 573., 574., 575., 576.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x6x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 337., 338., 339., 340.,
      341., 342., 343., 344., 345., 346., 347., 348., 349., 350., 351., 352.,
      369., 370., 371., 372., 373., 374., 375., 376., 377., 378., 379., 380.,
      381., 382., 383., 384., 529., 530., 531., 532., 533., 534., 535., 536.,
      537., 538., 539., 540., 541., 542., 543., 544., 561., 562., 563., 564.,
      565., 566., 567., 568., 569., 570., 571., 572., 573., 574., 575., 576.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x7x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15.,  16.,  17.,  18.,  18.,  18.,  21.,  22.,  23.,  24.,  24.,  24.,
      27.,  28.,  29.,  30.,  30.,  30.,  33.,  34.,  35.,  36.,  36.,  36.,
      39.,  40.,  41.,  42.,  42.,  42.,  39.,  40.,  41.,  42.,  42.,  42.,
      39.,  40.,  41.,  42.,  42.,  42.,  57.,  58.,  59.,  60.,  60.,  60.,
      63.,  64.,  65.,  66.,  66.,  66.,  69.,  70.,  71.,  72.,  72.,  72.,
      75.,  76.,  77.,  78.,  78.,  78.,  81.,  82.,  83.,  84.,  84.,  84.,
      81.,  82.,  83.,  84.,  84.,  84.,  81.,  82.,  83.,  84.,  84.,  84.,
      99.,  100., 101., 102., 102., 102., 105., 106., 107., 108., 108., 108.,
      111., 112., 113., 114., 114., 114., 117., 118., 119., 120., 120., 120.,
      123., 124., 125., 126., 126., 126., 123., 124., 125., 126., 126., 126.,
      123., 124., 125., 126., 126., 126.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x7x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29.,  30.,  35.,  36.,  41.,  42.,
                                         71.,  72.,  77.,  78.,  83.,  84.,
                                         113., 114., 119., 120., 125., 126.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x7x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  35.,  36.,  35.,  36.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,  47.,  48.,
      53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  59.,  60.,  59.,  60.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,  71.,  72.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  83.,  84.,  83.,  84.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  83.,  84.,  83.,  84.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  83.,  84.,  83.,  84.,
      113., 114., 115., 116., 117., 118., 119., 120., 119., 120., 119., 120.,
      125., 126., 127., 128., 129., 130., 131., 132., 131., 132., 131., 132.,
      137., 138., 139., 140., 141., 142., 143., 144., 143., 144., 143., 144.,
      149., 150., 151., 152., 153., 154., 155., 156., 155., 156., 155., 156.,
      161., 162., 163., 164., 165., 166., 167., 168., 167., 168., 167., 168.,
      161., 162., 163., 164., 165., 166., 167., 168., 167., 168., 167., 168.,
      161., 162., 163., 164., 165., 166., 167., 168., 167., 168., 167., 168.,
      197., 198., 199., 200., 201., 202., 203., 204., 203., 204., 203., 204.,
      209., 210., 211., 212., 213., 214., 215., 216., 215., 216., 215., 216.,
      221., 222., 223., 224., 225., 226., 227., 228., 227., 228., 227., 228.,
      233., 234., 235., 236., 237., 238., 239., 240., 239., 240., 239., 240.,
      245., 246., 247., 248., 249., 250., 251., 252., 251., 252., 251., 252.,
      245., 246., 247., 248., 249., 250., 251., 252., 251., 252., 251., 252.,
      245., 246., 247., 248., 249., 250., 251., 252., 251., 252., 251., 252.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x7x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  69.,  70.,  71.,  72.,  81.,  82.,  83.,  84.,
      141., 142., 143., 144., 153., 154., 155., 156., 165., 166., 167., 168.,
      225., 226., 227., 228., 237., 238., 239., 240., 249., 250., 251., 252.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x7x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,
      81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,
      105., 106., 107., 108., 109., 110., 111., 112., 113., 114., 115., 116.,
      117., 118., 119., 120., 117., 118., 119., 120., 117., 118., 119., 120.,
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      153., 154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 165., 166., 167., 168., 165., 166., 167., 168.,
      153., 154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 165., 166., 167., 168., 165., 166., 167., 168.,
      153., 154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 165., 166., 167., 168., 165., 166., 167., 168.,
      225., 226., 227., 228., 229., 230., 231., 232., 233., 234., 235., 236.,
      237., 238., 239., 240., 237., 238., 239., 240., 237., 238., 239., 240.,
      249., 250., 251., 252., 253., 254., 255., 256., 257., 258., 259., 260.,
      261., 262., 263., 264., 261., 262., 263., 264., 261., 262., 263., 264.,
      273., 274., 275., 276., 277., 278., 279., 280., 281., 282., 283., 284.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307., 308.,
      309., 310., 311., 312., 309., 310., 311., 312., 309., 310., 311., 312.,
      321., 322., 323., 324., 325., 326., 327., 328., 329., 330., 331., 332.,
      333., 334., 335., 336., 333., 334., 335., 336., 333., 334., 335., 336.,
      321., 322., 323., 324., 325., 326., 327., 328., 329., 330., 331., 332.,
      333., 334., 335., 336., 333., 334., 335., 336., 333., 334., 335., 336.,
      321., 322., 323., 324., 325., 326., 327., 328., 329., 330., 331., 332.,
      333., 334., 335., 336., 333., 334., 335., 336., 333., 334., 335., 336.,
      393., 394., 395., 396., 397., 398., 399., 400., 401., 402., 403., 404.,
      405., 406., 407., 408., 405., 406., 407., 408., 405., 406., 407., 408.,
      417., 418., 419., 420., 421., 422., 423., 424., 425., 426., 427., 428.,
      429., 430., 431., 432., 429., 430., 431., 432., 429., 430., 431., 432.,
      441., 442., 443., 444., 445., 446., 447., 448., 449., 450., 451., 452.,
      453., 454., 455., 456., 453., 454., 455., 456., 453., 454., 455., 456.,
      465., 466., 467., 468., 469., 470., 471., 472., 473., 474., 475., 476.,
      477., 478., 479., 480., 477., 478., 479., 480., 477., 478., 479., 480.,
      489., 490., 491., 492., 493., 494., 495., 496., 497., 498., 499., 500.,
      501., 502., 503., 504., 501., 502., 503., 504., 501., 502., 503., 504.,
      489., 490., 491., 492., 493., 494., 495., 496., 497., 498., 499., 500.,
      501., 502., 503., 504., 501., 502., 503., 504., 501., 502., 503., 504.,
      489., 490., 491., 492., 493., 494., 495., 496., 497., 498., 499., 500.,
      501., 502., 503., 504., 501., 502., 503., 504., 501., 502., 503., 504.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x7x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      113., 114., 115., 116., 117., 118., 119., 120., 137., 138., 139., 140.,
      141., 142., 143., 144., 161., 162., 163., 164., 165., 166., 167., 168.,
      281., 282., 283., 284., 285., 286., 287., 288., 305., 306., 307., 308.,
      309., 310., 311., 312., 329., 330., 331., 332., 333., 334., 335., 336.,
      449., 450., 451., 452., 453., 454., 455., 456., 473., 474., 475., 476.,
      477., 478., 479., 480., 497., 498., 499., 500., 501., 502., 503., 504.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.,  18.,  19.,  20.,  21.,  21.,  21.,  24.,  25.,  26.,  27.,  28.,
      28.,  28.,  31.,  32.,  33.,  34.,  35.,  35.,  35.,  38.,  39.,  40.,
      41.,  42.,  42.,  42.,  45.,  46.,  47.,  48.,  49.,  49.,  49.,  45.,
      46.,  47.,  48.,  49.,  49.,  49.,  45.,  46.,  47.,  48.,  49.,  49.,
      49.,  66.,  67.,  68.,  69.,  70.,  70.,  70.,  73.,  74.,  75.,  76.,
      77.,  77.,  77.,  80.,  81.,  82.,  83.,  84.,  84.,  84.,  87.,  88.,
      89.,  90.,  91.,  91.,  91.,  94.,  95.,  96.,  97.,  98.,  98.,  98.,
      94.,  95.,  96.,  97.,  98.,  98.,  98.,  94.,  95.,  96.,  97.,  98.,
      98.,  98.,  115., 116., 117., 118., 119., 119., 119., 122., 123., 124.,
      125., 126., 126., 126., 129., 130., 131., 132., 133., 133., 133., 136.,
      137., 138., 139., 140., 140., 140., 143., 144., 145., 146., 147., 147.,
      147., 143., 144., 145., 146., 147., 147., 147., 143., 144., 145., 146.,
      147., 147., 147.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  40.,  41.,  42.,  47.,  48.,  49.,
      82.,  83.,  84.,  89.,  90.,  91.,  96.,  97.,  98.,
      131., 132., 133., 138., 139., 140., 145., 146., 147.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,  41.,  42.,  41.,  42.,
      41.,  42.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,
      55.,  56.,  55.,  56.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  69.,  70.,  69.,  70.,  75.,  76.,  77.,  78.,  79.,  80.,
      81.,  82.,  83.,  84.,  83.,  84.,  83.,  84.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  97.,  98.,  97.,  98.,  97.,  98.,  89.,  90.,
      91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  97.,  98.,  97.,  98.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  97.,  98.,
      97.,  98.,  131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      139., 140., 139., 140., 145., 146., 147., 148., 149., 150., 151., 152.,
      153., 154., 153., 154., 153., 154., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 167., 168., 167., 168., 173., 174., 175., 176.,
      177., 178., 179., 180., 181., 182., 181., 182., 181., 182., 187., 188.,
      189., 190., 191., 192., 193., 194., 195., 196., 195., 196., 195., 196.,
      187., 188., 189., 190., 191., 192., 193., 194., 195., 196., 195., 196.,
      195., 196., 187., 188., 189., 190., 191., 192., 193., 194., 195., 196.,
      195., 196., 195., 196., 229., 230., 231., 232., 233., 234., 235., 236.,
      237., 238., 237., 238., 237., 238., 243., 244., 245., 246., 247., 248.,
      249., 250., 251., 252., 251., 252., 251., 252., 257., 258., 259., 260.,
      261., 262., 263., 264., 265., 266., 265., 266., 265., 266., 271., 272.,
      273., 274., 275., 276., 277., 278., 279., 280., 279., 280., 279., 280.,
      285., 286., 287., 288., 289., 290., 291., 292., 293., 294., 293., 294.,
      293., 294., 285., 286., 287., 288., 289., 290., 291., 292., 293., 294.,
      293., 294., 293., 294., 285., 286., 287., 288., 289., 290., 291., 292.,
      293., 294., 293., 294., 293., 294.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  79.,  80.,  81.,  82.,  83.,
      84.,  93.,  94.,  95.,  96.,  97.,  98.,  163., 164., 165., 166.,
      167., 168., 177., 178., 179., 180., 181., 182., 191., 192., 193.,
      194., 195., 196., 261., 262., 263., 264., 265., 266., 275., 276.,
      277., 278., 279., 280., 289., 290., 291., 292., 293., 294.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  81.,  82.,  83.,  84.,
      81.,  82.,  83.,  84.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      109., 110., 111., 112., 109., 110., 111., 112., 121., 122., 123., 124.,
      125., 126., 127., 128., 129., 130., 131., 132., 133., 134., 135., 136.,
      137., 138., 139., 140., 137., 138., 139., 140., 137., 138., 139., 140.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.,
      161., 162., 163., 164., 165., 166., 167., 168., 165., 166., 167., 168.,
      165., 166., 167., 168., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 193., 194., 195., 196.,
      193., 194., 195., 196., 193., 194., 195., 196., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      193., 194., 195., 196., 193., 194., 195., 196., 193., 194., 195., 196.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 193., 194., 195., 196., 193., 194., 195., 196.,
      193., 194., 195., 196., 261., 262., 263., 264., 265., 266., 267., 268.,
      269., 270., 271., 272., 273., 274., 275., 276., 277., 278., 279., 280.,
      277., 278., 279., 280., 277., 278., 279., 280., 289., 290., 291., 292.,
      293., 294., 295., 296., 297., 298., 299., 300., 301., 302., 303., 304.,
      305., 306., 307., 308., 305., 306., 307., 308., 305., 306., 307., 308.,
      317., 318., 319., 320., 321., 322., 323., 324., 325., 326., 327., 328.,
      329., 330., 331., 332., 333., 334., 335., 336., 333., 334., 335., 336.,
      333., 334., 335., 336., 345., 346., 347., 348., 349., 350., 351., 352.,
      353., 354., 355., 356., 357., 358., 359., 360., 361., 362., 363., 364.,
      361., 362., 363., 364., 361., 362., 363., 364., 373., 374., 375., 376.,
      377., 378., 379., 380., 381., 382., 383., 384., 385., 386., 387., 388.,
      389., 390., 391., 392., 389., 390., 391., 392., 389., 390., 391., 392.,
      373., 374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,
      385., 386., 387., 388., 389., 390., 391., 392., 389., 390., 391., 392.,
      389., 390., 391., 392., 373., 374., 375., 376., 377., 378., 379., 380.,
      381., 382., 383., 384., 385., 386., 387., 388., 389., 390., 391., 392.,
      389., 390., 391., 392., 389., 390., 391., 392., 457., 458., 459., 460.,
      461., 462., 463., 464., 465., 466., 467., 468., 469., 470., 471., 472.,
      473., 474., 475., 476., 473., 474., 475., 476., 473., 474., 475., 476.,
      485., 486., 487., 488., 489., 490., 491., 492., 493., 494., 495., 496.,
      497., 498., 499., 500., 501., 502., 503., 504., 501., 502., 503., 504.,
      501., 502., 503., 504., 513., 514., 515., 516., 517., 518., 519., 520.,
      521., 522., 523., 524., 525., 526., 527., 528., 529., 530., 531., 532.,
      529., 530., 531., 532., 529., 530., 531., 532., 541., 542., 543., 544.,
      545., 546., 547., 548., 549., 550., 551., 552., 553., 554., 555., 556.,
      557., 558., 559., 560., 557., 558., 559., 560., 557., 558., 559., 560.,
      569., 570., 571., 572., 573., 574., 575., 576., 577., 578., 579., 580.,
      581., 582., 583., 584., 585., 586., 587., 588., 585., 586., 587., 588.,
      585., 586., 587., 588., 569., 570., 571., 572., 573., 574., 575., 576.,
      577., 578., 579., 580., 581., 582., 583., 584., 585., 586., 587., 588.,
      585., 586., 587., 588., 585., 586., 587., 588., 569., 570., 571., 572.,
      573., 574., 575., 576., 577., 578., 579., 580., 581., 582., 583., 584.,
      585., 586., 587., 588., 585., 586., 587., 588., 585., 586., 587., 588.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      185., 186., 187., 188., 189., 190., 191., 192., 193., 194., 195., 196.,
      325., 326., 327., 328., 329., 330., 331., 332., 333., 334., 335., 336.,
      353., 354., 355., 356., 357., 358., 359., 360., 361., 362., 363., 364.,
      381., 382., 383., 384., 385., 386., 387., 388., 389., 390., 391., 392.,
      521., 522., 523., 524., 525., 526., 527., 528., 529., 530., 531., 532.,
      549., 550., 551., 552., 553., 554., 555., 556., 557., 558., 559., 560.,
      577., 578., 579., 580., 581., 582., 583., 584., 585., 586., 587., 588.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19.,  20.,  21.,  22.,  23.,  24.,  24.,  24.,  27.,  28.,  29.,  30.,
      31.,  32.,  32.,  32.,  35.,  36.,  37.,  38.,  39.,  40.,  40.,  40.,
      43.,  44.,  45.,  46.,  47.,  48.,  48.,  48.,  51.,  52.,  53.,  54.,
      55.,  56.,  56.,  56.,  51.,  52.,  53.,  54.,  55.,  56.,  56.,  56.,
      51.,  52.,  53.,  54.,  55.,  56.,  56.,  56.,  75.,  76.,  77.,  78.,
      79.,  80.,  80.,  80.,  83.,  84.,  85.,  86.,  87.,  88.,  88.,  88.,
      91.,  92.,  93.,  94.,  95.,  96.,  96.,  96.,  99.,  100., 101., 102.,
      103., 104., 104., 104., 107., 108., 109., 110., 111., 112., 112., 112.,
      107., 108., 109., 110., 111., 112., 112., 112., 107., 108., 109., 110.,
      111., 112., 112., 112., 131., 132., 133., 134., 135., 136., 136., 136.,
      139., 140., 141., 142., 143., 144., 144., 144., 147., 148., 149., 150.,
      151., 152., 152., 152., 155., 156., 157., 158., 159., 160., 160., 160.,
      163., 164., 165., 166., 167., 168., 168., 168., 163., 164., 165., 166.,
      167., 168., 168., 168., 163., 164., 165., 166., 167., 168., 168., 168.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  45.,  46.,  47.,  48.,  53.,  54.,  55.,  56.,
      93.,  94.,  95.,  96.,  101., 102., 103., 104., 109., 110., 111., 112.,
      149., 150., 151., 152., 157., 158., 159., 160., 165., 166., 167., 168.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      47.,  48.,  47.,  48.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  63.,  64.,  63.,  64.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  79.,  80.,  79.,  80.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      95.,  96.,  95.,  96.,  101., 102., 103., 104., 105., 106., 107., 108.,
      109., 110., 111., 112., 111., 112., 111., 112., 101., 102., 103., 104.,
      105., 106., 107., 108., 109., 110., 111., 112., 111., 112., 111., 112.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      111., 112., 111., 112., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 159., 160., 159., 160., 165., 166., 167., 168.,
      169., 170., 171., 172., 173., 174., 175., 176., 175., 176., 175., 176.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      191., 192., 191., 192., 197., 198., 199., 200., 201., 202., 203., 204.,
      205., 206., 207., 208., 207., 208., 207., 208., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 223., 224., 223., 224.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      223., 224., 223., 224., 213., 214., 215., 216., 217., 218., 219., 220.,
      221., 222., 223., 224., 223., 224., 223., 224., 261., 262., 263., 264.,
      265., 266., 267., 268., 269., 270., 271., 272., 271., 272., 271., 272.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      287., 288., 287., 288., 293., 294., 295., 296., 297., 298., 299., 300.,
      301., 302., 303., 304., 303., 304., 303., 304., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 319., 320., 319., 320.,
      325., 326., 327., 328., 329., 330., 331., 332., 333., 334., 335., 336.,
      335., 336., 335., 336., 325., 326., 327., 328., 329., 330., 331., 332.,
      333., 334., 335., 336., 335., 336., 335., 336., 325., 326., 327., 328.,
      329., 330., 331., 332., 333., 334., 335., 336., 335., 336., 335., 336.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  105., 106., 107., 108., 109., 110., 111., 112.,
      185., 186., 187., 188., 189., 190., 191., 192., 201., 202., 203., 204.,
      205., 206., 207., 208., 217., 218., 219., 220., 221., 222., 223., 224.,
      297., 298., 299., 300., 301., 302., 303., 304., 313., 314., 315., 316.,
      317., 318., 319., 320., 329., 330., 331., 332., 333., 334., 335., 336.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 125., 126., 127., 128.,
      125., 126., 127., 128., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      189., 190., 191., 192., 189., 190., 191., 192., 201., 202., 203., 204.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 221., 222., 223., 224.,
      221., 222., 223., 224., 201., 202., 203., 204., 205., 206., 207., 208.,
      209., 210., 211., 212., 213., 214., 215., 216., 217., 218., 219., 220.,
      221., 222., 223., 224., 221., 222., 223., 224., 221., 222., 223., 224.,
      201., 202., 203., 204., 205., 206., 207., 208., 209., 210., 211., 212.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      221., 222., 223., 224., 221., 222., 223., 224., 297., 298., 299., 300.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 329., 330., 331., 332., 333., 334., 335., 336.,
      337., 338., 339., 340., 341., 342., 343., 344., 345., 346., 347., 348.,
      349., 350., 351., 352., 349., 350., 351., 352., 349., 350., 351., 352.,
      361., 362., 363., 364., 365., 366., 367., 368., 369., 370., 371., 372.,
      373., 374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,
      381., 382., 383., 384., 381., 382., 383., 384., 393., 394., 395., 396.,
      397., 398., 399., 400., 401., 402., 403., 404., 405., 406., 407., 408.,
      409., 410., 411., 412., 413., 414., 415., 416., 413., 414., 415., 416.,
      413., 414., 415., 416., 425., 426., 427., 428., 429., 430., 431., 432.,
      433., 434., 435., 436., 437., 438., 439., 440., 441., 442., 443., 444.,
      445., 446., 447., 448., 445., 446., 447., 448., 445., 446., 447., 448.,
      425., 426., 427., 428., 429., 430., 431., 432., 433., 434., 435., 436.,
      437., 438., 439., 440., 441., 442., 443., 444., 445., 446., 447., 448.,
      445., 446., 447., 448., 445., 446., 447., 448., 425., 426., 427., 428.,
      429., 430., 431., 432., 433., 434., 435., 436., 437., 438., 439., 440.,
      441., 442., 443., 444., 445., 446., 447., 448., 445., 446., 447., 448.,
      445., 446., 447., 448., 521., 522., 523., 524., 525., 526., 527., 528.,
      529., 530., 531., 532., 533., 534., 535., 536., 537., 538., 539., 540.,
      541., 542., 543., 544., 541., 542., 543., 544., 541., 542., 543., 544.,
      553., 554., 555., 556., 557., 558., 559., 560., 561., 562., 563., 564.,
      565., 566., 567., 568., 569., 570., 571., 572., 573., 574., 575., 576.,
      573., 574., 575., 576., 573., 574., 575., 576., 585., 586., 587., 588.,
      589., 590., 591., 592., 593., 594., 595., 596., 597., 598., 599., 600.,
      601., 602., 603., 604., 605., 606., 607., 608., 605., 606., 607., 608.,
      605., 606., 607., 608., 617., 618., 619., 620., 621., 622., 623., 624.,
      625., 626., 627., 628., 629., 630., 631., 632., 633., 634., 635., 636.,
      637., 638., 639., 640., 637., 638., 639., 640., 637., 638., 639., 640.,
      649., 650., 651., 652., 653., 654., 655., 656., 657., 658., 659., 660.,
      661., 662., 663., 664., 665., 666., 667., 668., 669., 670., 671., 672.,
      669., 670., 671., 672., 669., 670., 671., 672., 649., 650., 651., 652.,
      653., 654., 655., 656., 657., 658., 659., 660., 661., 662., 663., 664.,
      665., 666., 667., 668., 669., 670., 671., 672., 669., 670., 671., 672.,
      669., 670., 671., 672., 649., 650., 651., 652., 653., 654., 655., 656.,
      657., 658., 659., 660., 661., 662., 663., 664., 665., 666., 667., 668.,
      669., 670., 671., 672., 669., 670., 671., 672., 669., 670., 671., 672.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 209., 210., 211., 212.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      369., 370., 371., 372., 373., 374., 375., 376., 377., 378., 379., 380.,
      381., 382., 383., 384., 401., 402., 403., 404., 405., 406., 407., 408.,
      409., 410., 411., 412., 413., 414., 415., 416., 433., 434., 435., 436.,
      437., 438., 439., 440., 441., 442., 443., 444., 445., 446., 447., 448.,
      593., 594., 595., 596., 597., 598., 599., 600., 601., 602., 603., 604.,
      605., 606., 607., 608., 625., 626., 627., 628., 629., 630., 631., 632.,
      633., 634., 635., 636., 637., 638., 639., 640., 657., 658., 659., 660.,
      661., 662., 663., 664., 665., 666., 667., 668., 669., 670., 671., 672.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x8x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15.,  16.,  17.,  18.,  18.,  18.,  21.,  22.,  23.,  24.,  24.,  24.,
      27.,  28.,  29.,  30.,  30.,  30.,  33.,  34.,  35.,  36.,  36.,  36.,
      39.,  40.,  41.,  42.,  42.,  42.,  45.,  46.,  47.,  48.,  48.,  48.,
      45.,  46.,  47.,  48.,  48.,  48.,  45.,  46.,  47.,  48.,  48.,  48.,
      63.,  64.,  65.,  66.,  66.,  66.,  69.,  70.,  71.,  72.,  72.,  72.,
      75.,  76.,  77.,  78.,  78.,  78.,  81.,  82.,  83.,  84.,  84.,  84.,
      87.,  88.,  89.,  90.,  90.,  90.,  93.,  94.,  95.,  96.,  96.,  96.,
      93.,  94.,  95.,  96.,  96.,  96.,  93.,  94.,  95.,  96.,  96.,  96.,
      111., 112., 113., 114., 114., 114., 117., 118., 119., 120., 120., 120.,
      123., 124., 125., 126., 126., 126., 129., 130., 131., 132., 132., 132.,
      135., 136., 137., 138., 138., 138., 141., 142., 143., 144., 144., 144.,
      141., 142., 143., 144., 144., 144., 141., 142., 143., 144., 144., 144.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x8x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29., 30., 35., 36., 41.,  42.,  47.,  48.,  77.,  78.,  83.,  84.,
      89., 90., 95., 96., 125., 126., 131., 132., 137., 138., 143., 144.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x8x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  35.,  36.,  35.,  36.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,  47.,  48.,
      53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  59.,  60.,  59.,  60.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,  71.,  72.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  83.,  84.,  83.,  84.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,  95.,  96.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,  95.,  96.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,  95.,  96.,
      125., 126., 127., 128., 129., 130., 131., 132., 131., 132., 131., 132.,
      137., 138., 139., 140., 141., 142., 143., 144., 143., 144., 143., 144.,
      149., 150., 151., 152., 153., 154., 155., 156., 155., 156., 155., 156.,
      161., 162., 163., 164., 165., 166., 167., 168., 167., 168., 167., 168.,
      173., 174., 175., 176., 177., 178., 179., 180., 179., 180., 179., 180.,
      185., 186., 187., 188., 189., 190., 191., 192., 191., 192., 191., 192.,
      185., 186., 187., 188., 189., 190., 191., 192., 191., 192., 191., 192.,
      185., 186., 187., 188., 189., 190., 191., 192., 191., 192., 191., 192.,
      221., 222., 223., 224., 225., 226., 227., 228., 227., 228., 227., 228.,
      233., 234., 235., 236., 237., 238., 239., 240., 239., 240., 239., 240.,
      245., 246., 247., 248., 249., 250., 251., 252., 251., 252., 251., 252.,
      257., 258., 259., 260., 261., 262., 263., 264., 263., 264., 263., 264.,
      269., 270., 271., 272., 273., 274., 275., 276., 275., 276., 275., 276.,
      281., 282., 283., 284., 285., 286., 287., 288., 287., 288., 287., 288.,
      281., 282., 283., 284., 285., 286., 287., 288., 287., 288., 287., 288.,
      281., 282., 283., 284., 285., 286., 287., 288., 287., 288., 287., 288.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x8x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  69.,  70.,  71.,  72.,  81.,  82.,  83.,  84.,
      93.,  94.,  95.,  96.,  153., 154., 155., 156., 165., 166., 167., 168.,
      177., 178., 179., 180., 189., 190., 191., 192., 249., 250., 251., 252.,
      261., 262., 263., 264., 273., 274., 275., 276., 285., 286., 287., 288.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x8x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,
      81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,
      105., 106., 107., 108., 109., 110., 111., 112., 113., 114., 115., 116.,
      117., 118., 119., 120., 117., 118., 119., 120., 117., 118., 119., 120.,
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      153., 154., 155., 156., 157., 158., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 165., 166., 167., 168., 165., 166., 167., 168.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.,
      249., 250., 251., 252., 253., 254., 255., 256., 257., 258., 259., 260.,
      261., 262., 263., 264., 261., 262., 263., 264., 261., 262., 263., 264.,
      273., 274., 275., 276., 277., 278., 279., 280., 281., 282., 283., 284.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307., 308.,
      309., 310., 311., 312., 309., 310., 311., 312., 309., 310., 311., 312.,
      321., 322., 323., 324., 325., 326., 327., 328., 329., 330., 331., 332.,
      333., 334., 335., 336., 333., 334., 335., 336., 333., 334., 335., 336.,
      345., 346., 347., 348., 349., 350., 351., 352., 353., 354., 355., 356.,
      357., 358., 359., 360., 357., 358., 359., 360., 357., 358., 359., 360.,
      369., 370., 371., 372., 373., 374., 375., 376., 377., 378., 379., 380.,
      381., 382., 383., 384., 381., 382., 383., 384., 381., 382., 383., 384.,
      369., 370., 371., 372., 373., 374., 375., 376., 377., 378., 379., 380.,
      381., 382., 383., 384., 381., 382., 383., 384., 381., 382., 383., 384.,
      369., 370., 371., 372., 373., 374., 375., 376., 377., 378., 379., 380.,
      381., 382., 383., 384., 381., 382., 383., 384., 381., 382., 383., 384.,
      441., 442., 443., 444., 445., 446., 447., 448., 449., 450., 451., 452.,
      453., 454., 455., 456., 453., 454., 455., 456., 453., 454., 455., 456.,
      465., 466., 467., 468., 469., 470., 471., 472., 473., 474., 475., 476.,
      477., 478., 479., 480., 477., 478., 479., 480., 477., 478., 479., 480.,
      489., 490., 491., 492., 493., 494., 495., 496., 497., 498., 499., 500.,
      501., 502., 503., 504., 501., 502., 503., 504., 501., 502., 503., 504.,
      513., 514., 515., 516., 517., 518., 519., 520., 521., 522., 523., 524.,
      525., 526., 527., 528., 525., 526., 527., 528., 525., 526., 527., 528.,
      537., 538., 539., 540., 541., 542., 543., 544., 545., 546., 547., 548.,
      549., 550., 551., 552., 549., 550., 551., 552., 549., 550., 551., 552.,
      561., 562., 563., 564., 565., 566., 567., 568., 569., 570., 571., 572.,
      573., 574., 575., 576., 573., 574., 575., 576., 573., 574., 575., 576.,
      561., 562., 563., 564., 565., 566., 567., 568., 569., 570., 571., 572.,
      573., 574., 575., 576., 573., 574., 575., 576., 573., 574., 575., 576.,
      561., 562., 563., 564., 565., 566., 567., 568., 569., 570., 571., 572.,
      573., 574., 575., 576., 573., 574., 575., 576., 573., 574., 575., 576.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x8x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      113., 114., 115., 116., 117., 118., 119., 120., 137., 138., 139., 140.,
      141., 142., 143., 144., 161., 162., 163., 164., 165., 166., 167., 168.,
      185., 186., 187., 188., 189., 190., 191., 192., 305., 306., 307., 308.,
      309., 310., 311., 312., 329., 330., 331., 332., 333., 334., 335., 336.,
      353., 354., 355., 356., 357., 358., 359., 360., 377., 378., 379., 380.,
      381., 382., 383., 384., 497., 498., 499., 500., 501., 502., 503., 504.,
      521., 522., 523., 524., 525., 526., 527., 528., 545., 546., 547., 548.,
      549., 550., 551., 552., 569., 570., 571., 572., 573., 574., 575., 576.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.,  18.,  19.,  20.,  21.,  21.,  21.,  24.,  25.,  26.,  27.,  28.,
      28.,  28.,  31.,  32.,  33.,  34.,  35.,  35.,  35.,  38.,  39.,  40.,
      41.,  42.,  42.,  42.,  45.,  46.,  47.,  48.,  49.,  49.,  49.,  52.,
      53.,  54.,  55.,  56.,  56.,  56.,  52.,  53.,  54.,  55.,  56.,  56.,
      56.,  52.,  53.,  54.,  55.,  56.,  56.,  56.,  73.,  74.,  75.,  76.,
      77.,  77.,  77.,  80.,  81.,  82.,  83.,  84.,  84.,  84.,  87.,  88.,
      89.,  90.,  91.,  91.,  91.,  94.,  95.,  96.,  97.,  98.,  98.,  98.,
      101., 102., 103., 104., 105., 105., 105., 108., 109., 110., 111., 112.,
      112., 112., 108., 109., 110., 111., 112., 112., 112., 108., 109., 110.,
      111., 112., 112., 112., 129., 130., 131., 132., 133., 133., 133., 136.,
      137., 138., 139., 140., 140., 140., 143., 144., 145., 146., 147., 147.,
      147., 150., 151., 152., 153., 154., 154., 154., 157., 158., 159., 160.,
      161., 161., 161., 164., 165., 166., 167., 168., 168., 168., 164., 165.,
      166., 167., 168., 168., 168., 164., 165., 166., 167., 168., 168., 168.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  40.,  41.,  42.,  47.,  48.,  49.,  54.,  55.,  56.,
      89.,  90.,  91.,  96.,  97.,  98.,  103., 104., 105., 110., 111., 112.,
      145., 146., 147., 152., 153., 154., 159., 160., 161., 166., 167., 168.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,  41.,  42.,  41.,  42.,
      41.,  42.,  47.,  48.,  49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,
      55.,  56.,  55.,  56.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  69.,  70.,  69.,  70.,  75.,  76.,  77.,  78.,  79.,  80.,
      81.,  82.,  83.,  84.,  83.,  84.,  83.,  84.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  97.,  98.,  97.,  98.,  97.,  98.,  103., 104.,
      105., 106., 107., 108., 109., 110., 111., 112., 111., 112., 111., 112.,
      103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 111., 112.,
      111., 112., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      111., 112., 111., 112., 145., 146., 147., 148., 149., 150., 151., 152.,
      153., 154., 153., 154., 153., 154., 159., 160., 161., 162., 163., 164.,
      165., 166., 167., 168., 167., 168., 167., 168., 173., 174., 175., 176.,
      177., 178., 179., 180., 181., 182., 181., 182., 181., 182., 187., 188.,
      189., 190., 191., 192., 193., 194., 195., 196., 195., 196., 195., 196.,
      201., 202., 203., 204., 205., 206., 207., 208., 209., 210., 209., 210.,
      209., 210., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      223., 224., 223., 224., 215., 216., 217., 218., 219., 220., 221., 222.,
      223., 224., 223., 224., 223., 224., 215., 216., 217., 218., 219., 220.,
      221., 222., 223., 224., 223., 224., 223., 224., 257., 258., 259., 260.,
      261., 262., 263., 264., 265., 266., 265., 266., 265., 266., 271., 272.,
      273., 274., 275., 276., 277., 278., 279., 280., 279., 280., 279., 280.,
      285., 286., 287., 288., 289., 290., 291., 292., 293., 294., 293., 294.,
      293., 294., 299., 300., 301., 302., 303., 304., 305., 306., 307., 308.,
      307., 308., 307., 308., 313., 314., 315., 316., 317., 318., 319., 320.,
      321., 322., 321., 322., 321., 322., 327., 328., 329., 330., 331., 332.,
      333., 334., 335., 336., 335., 336., 335., 336., 327., 328., 329., 330.,
      331., 332., 333., 334., 335., 336., 335., 336., 335., 336., 327., 328.,
      329., 330., 331., 332., 333., 334., 335., 336., 335., 336., 335., 336.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  79.,  80.,  81.,  82.,  83.,  84.,
      93.,  94.,  95.,  96.,  97.,  98.,  107., 108., 109., 110., 111., 112.,
      177., 178., 179., 180., 181., 182., 191., 192., 193., 194., 195., 196.,
      205., 206., 207., 208., 209., 210., 219., 220., 221., 222., 223., 224.,
      289., 290., 291., 292., 293., 294., 303., 304., 305., 306., 307., 308.,
      317., 318., 319., 320., 321., 322., 331., 332., 333., 334., 335., 336.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  81.,  82.,  83.,  84.,
      81.,  82.,  83.,  84.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      109., 110., 111., 112., 109., 110., 111., 112., 121., 122., 123., 124.,
      125., 126., 127., 128., 129., 130., 131., 132., 133., 134., 135., 136.,
      137., 138., 139., 140., 137., 138., 139., 140., 137., 138., 139., 140.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.,
      161., 162., 163., 164., 165., 166., 167., 168., 165., 166., 167., 168.,
      165., 166., 167., 168., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 193., 194., 195., 196.,
      193., 194., 195., 196., 193., 194., 195., 196., 205., 206., 207., 208.,
      209., 210., 211., 212., 213., 214., 215., 216., 217., 218., 219., 220.,
      221., 222., 223., 224., 221., 222., 223., 224., 221., 222., 223., 224.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 221., 222., 223., 224.,
      221., 222., 223., 224., 205., 206., 207., 208., 209., 210., 211., 212.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      221., 222., 223., 224., 221., 222., 223., 224., 289., 290., 291., 292.,
      293., 294., 295., 296., 297., 298., 299., 300., 301., 302., 303., 304.,
      305., 306., 307., 308., 305., 306., 307., 308., 305., 306., 307., 308.,
      317., 318., 319., 320., 321., 322., 323., 324., 325., 326., 327., 328.,
      329., 330., 331., 332., 333., 334., 335., 336., 333., 334., 335., 336.,
      333., 334., 335., 336., 345., 346., 347., 348., 349., 350., 351., 352.,
      353., 354., 355., 356., 357., 358., 359., 360., 361., 362., 363., 364.,
      361., 362., 363., 364., 361., 362., 363., 364., 373., 374., 375., 376.,
      377., 378., 379., 380., 381., 382., 383., 384., 385., 386., 387., 388.,
      389., 390., 391., 392., 389., 390., 391., 392., 389., 390., 391., 392.,
      401., 402., 403., 404., 405., 406., 407., 408., 409., 410., 411., 412.,
      413., 414., 415., 416., 417., 418., 419., 420., 417., 418., 419., 420.,
      417., 418., 419., 420., 429., 430., 431., 432., 433., 434., 435., 436.,
      437., 438., 439., 440., 441., 442., 443., 444., 445., 446., 447., 448.,
      445., 446., 447., 448., 445., 446., 447., 448., 429., 430., 431., 432.,
      433., 434., 435., 436., 437., 438., 439., 440., 441., 442., 443., 444.,
      445., 446., 447., 448., 445., 446., 447., 448., 445., 446., 447., 448.,
      429., 430., 431., 432., 433., 434., 435., 436., 437., 438., 439., 440.,
      441., 442., 443., 444., 445., 446., 447., 448., 445., 446., 447., 448.,
      445., 446., 447., 448., 513., 514., 515., 516., 517., 518., 519., 520.,
      521., 522., 523., 524., 525., 526., 527., 528., 529., 530., 531., 532.,
      529., 530., 531., 532., 529., 530., 531., 532., 541., 542., 543., 544.,
      545., 546., 547., 548., 549., 550., 551., 552., 553., 554., 555., 556.,
      557., 558., 559., 560., 557., 558., 559., 560., 557., 558., 559., 560.,
      569., 570., 571., 572., 573., 574., 575., 576., 577., 578., 579., 580.,
      581., 582., 583., 584., 585., 586., 587., 588., 585., 586., 587., 588.,
      585., 586., 587., 588., 597., 598., 599., 600., 601., 602., 603., 604.,
      605., 606., 607., 608., 609., 610., 611., 612., 613., 614., 615., 616.,
      613., 614., 615., 616., 613., 614., 615., 616., 625., 626., 627., 628.,
      629., 630., 631., 632., 633., 634., 635., 636., 637., 638., 639., 640.,
      641., 642., 643., 644., 641., 642., 643., 644., 641., 642., 643., 644.,
      653., 654., 655., 656., 657., 658., 659., 660., 661., 662., 663., 664.,
      665., 666., 667., 668., 669., 670., 671., 672., 669., 670., 671., 672.,
      669., 670., 671., 672., 653., 654., 655., 656., 657., 658., 659., 660.,
      661., 662., 663., 664., 665., 666., 667., 668., 669., 670., 671., 672.,
      669., 670., 671., 672., 669., 670., 671., 672., 653., 654., 655., 656.,
      657., 658., 659., 660., 661., 662., 663., 664., 665., 666., 667., 668.,
      669., 670., 671., 672., 669., 670., 671., 672., 669., 670., 671., 672.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      185., 186., 187., 188., 189., 190., 191., 192., 193., 194., 195., 196.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      353., 354., 355., 356., 357., 358., 359., 360., 361., 362., 363., 364.,
      381., 382., 383., 384., 385., 386., 387., 388., 389., 390., 391., 392.,
      409., 410., 411., 412., 413., 414., 415., 416., 417., 418., 419., 420.,
      437., 438., 439., 440., 441., 442., 443., 444., 445., 446., 447., 448.,
      577., 578., 579., 580., 581., 582., 583., 584., 585., 586., 587., 588.,
      605., 606., 607., 608., 609., 610., 611., 612., 613., 614., 615., 616.,
      633., 634., 635., 636., 637., 638., 639., 640., 641., 642., 643., 644.,
      661., 662., 663., 664., 665., 666., 667., 668., 669., 670., 671., 672.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19.,  20.,  21.,  22.,  23.,  24.,  24.,  24.,  27.,  28.,  29.,  30.,
      31.,  32.,  32.,  32.,  35.,  36.,  37.,  38.,  39.,  40.,  40.,  40.,
      43.,  44.,  45.,  46.,  47.,  48.,  48.,  48.,  51.,  52.,  53.,  54.,
      55.,  56.,  56.,  56.,  59.,  60.,  61.,  62.,  63.,  64.,  64.,  64.,
      59.,  60.,  61.,  62.,  63.,  64.,  64.,  64.,  59.,  60.,  61.,  62.,
      63.,  64.,  64.,  64.,  83.,  84.,  85.,  86.,  87.,  88.,  88.,  88.,
      91.,  92.,  93.,  94.,  95.,  96.,  96.,  96.,  99.,  100., 101., 102.,
      103., 104., 104., 104., 107., 108., 109., 110., 111., 112., 112., 112.,
      115., 116., 117., 118., 119., 120., 120., 120., 123., 124., 125., 126.,
      127., 128., 128., 128., 123., 124., 125., 126., 127., 128., 128., 128.,
      123., 124., 125., 126., 127., 128., 128., 128., 147., 148., 149., 150.,
      151., 152., 152., 152., 155., 156., 157., 158., 159., 160., 160., 160.,
      163., 164., 165., 166., 167., 168., 168., 168., 171., 172., 173., 174.,
      175., 176., 176., 176., 179., 180., 181., 182., 183., 184., 184., 184.,
      187., 188., 189., 190., 191., 192., 192., 192., 187., 188., 189., 190.,
      191., 192., 192., 192., 187., 188., 189., 190., 191., 192., 192., 192.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  45.,  46.,  47.,  48.,  53.,  54.,  55.,  56.,
      61.,  62.,  63.,  64.,  101., 102., 103., 104., 109., 110., 111., 112.,
      117., 118., 119., 120., 125., 126., 127., 128., 165., 166., 167., 168.,
      173., 174., 175., 176., 181., 182., 183., 184., 189., 190., 191., 192.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
      47.,  48.,  47.,  48.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  63.,  64.,  63.,  64.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  79.,  80.,  79.,  80.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      95.,  96.,  95.,  96.,  101., 102., 103., 104., 105., 106., 107., 108.,
      109., 110., 111., 112., 111., 112., 111., 112., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 127., 128., 127., 128.,
      117., 118., 119., 120., 121., 122., 123., 124., 125., 126., 127., 128.,
      127., 128., 127., 128., 117., 118., 119., 120., 121., 122., 123., 124.,
      125., 126., 127., 128., 127., 128., 127., 128., 165., 166., 167., 168.,
      169., 170., 171., 172., 173., 174., 175., 176., 175., 176., 175., 176.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      191., 192., 191., 192., 197., 198., 199., 200., 201., 202., 203., 204.,
      205., 206., 207., 208., 207., 208., 207., 208., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 223., 224., 223., 224.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      239., 240., 239., 240., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 255., 256., 255., 256., 245., 246., 247., 248.,
      249., 250., 251., 252., 253., 254., 255., 256., 255., 256., 255., 256.,
      245., 246., 247., 248., 249., 250., 251., 252., 253., 254., 255., 256.,
      255., 256., 255., 256., 293., 294., 295., 296., 297., 298., 299., 300.,
      301., 302., 303., 304., 303., 304., 303., 304., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 319., 320., 319., 320.,
      325., 326., 327., 328., 329., 330., 331., 332., 333., 334., 335., 336.,
      335., 336., 335., 336., 341., 342., 343., 344., 345., 346., 347., 348.,
      349., 350., 351., 352., 351., 352., 351., 352., 357., 358., 359., 360.,
      361., 362., 363., 364., 365., 366., 367., 368., 367., 368., 367., 368.,
      373., 374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,
      383., 384., 383., 384., 373., 374., 375., 376., 377., 378., 379., 380.,
      381., 382., 383., 384., 383., 384., 383., 384., 373., 374., 375., 376.,
      377., 378., 379., 380., 381., 382., 383., 384., 383., 384., 383., 384.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  105., 106., 107., 108., 109., 110., 111., 112.,
      121., 122., 123., 124., 125., 126., 127., 128., 201., 202., 203., 204.,
      205., 206., 207., 208., 217., 218., 219., 220., 221., 222., 223., 224.,
      233., 234., 235., 236., 237., 238., 239., 240., 249., 250., 251., 252.,
      253., 254., 255., 256., 329., 330., 331., 332., 333., 334., 335., 336.,
      345., 346., 347., 348., 349., 350., 351., 352., 361., 362., 363., 364.,
      365., 366., 367., 368., 377., 378., 379., 380., 381., 382., 383., 384.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, SAME3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 125., 126., 127., 128.,
      125., 126., 127., 128., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      189., 190., 191., 192., 189., 190., 191., 192., 201., 202., 203., 204.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 221., 222., 223., 224.,
      221., 222., 223., 224., 233., 234., 235., 236., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 253., 254., 255., 256., 253., 254., 255., 256.,
      233., 234., 235., 236., 237., 238., 239., 240., 241., 242., 243., 244.,
      245., 246., 247., 248., 249., 250., 251., 252., 253., 254., 255., 256.,
      253., 254., 255., 256., 253., 254., 255., 256., 233., 234., 235., 236.,
      237., 238., 239., 240., 241., 242., 243., 244., 245., 246., 247., 248.,
      249., 250., 251., 252., 253., 254., 255., 256., 253., 254., 255., 256.,
      253., 254., 255., 256., 329., 330., 331., 332., 333., 334., 335., 336.,
      337., 338., 339., 340., 341., 342., 343., 344., 345., 346., 347., 348.,
      349., 350., 351., 352., 349., 350., 351., 352., 349., 350., 351., 352.,
      361., 362., 363., 364., 365., 366., 367., 368., 369., 370., 371., 372.,
      373., 374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,
      381., 382., 383., 384., 381., 382., 383., 384., 393., 394., 395., 396.,
      397., 398., 399., 400., 401., 402., 403., 404., 405., 406., 407., 408.,
      409., 410., 411., 412., 413., 414., 415., 416., 413., 414., 415., 416.,
      413., 414., 415., 416., 425., 426., 427., 428., 429., 430., 431., 432.,
      433., 434., 435., 436., 437., 438., 439., 440., 441., 442., 443., 444.,
      445., 446., 447., 448., 445., 446., 447., 448., 445., 446., 447., 448.,
      457., 458., 459., 460., 461., 462., 463., 464., 465., 466., 467., 468.,
      469., 470., 471., 472., 473., 474., 475., 476., 477., 478., 479., 480.,
      477., 478., 479., 480., 477., 478., 479., 480., 489., 490., 491., 492.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      505., 506., 507., 508., 509., 510., 511., 512., 509., 510., 511., 512.,
      509., 510., 511., 512., 489., 490., 491., 492., 493., 494., 495., 496.,
      497., 498., 499., 500., 501., 502., 503., 504., 505., 506., 507., 508.,
      509., 510., 511., 512., 509., 510., 511., 512., 509., 510., 511., 512.,
      489., 490., 491., 492., 493., 494., 495., 496., 497., 498., 499., 500.,
      501., 502., 503., 504., 505., 506., 507., 508., 509., 510., 511., 512.,
      509., 510., 511., 512., 509., 510., 511., 512., 585., 586., 587., 588.,
      589., 590., 591., 592., 593., 594., 595., 596., 597., 598., 599., 600.,
      601., 602., 603., 604., 605., 606., 607., 608., 605., 606., 607., 608.,
      605., 606., 607., 608., 617., 618., 619., 620., 621., 622., 623., 624.,
      625., 626., 627., 628., 629., 630., 631., 632., 633., 634., 635., 636.,
      637., 638., 639., 640., 637., 638., 639., 640., 637., 638., 639., 640.,
      649., 650., 651., 652., 653., 654., 655., 656., 657., 658., 659., 660.,
      661., 662., 663., 664., 665., 666., 667., 668., 669., 670., 671., 672.,
      669., 670., 671., 672., 669., 670., 671., 672., 681., 682., 683., 684.,
      685., 686., 687., 688., 689., 690., 691., 692., 693., 694., 695., 696.,
      697., 698., 699., 700., 701., 702., 703., 704., 701., 702., 703., 704.,
      701., 702., 703., 704., 713., 714., 715., 716., 717., 718., 719., 720.,
      721., 722., 723., 724., 725., 726., 727., 728., 729., 730., 731., 732.,
      733., 734., 735., 736., 733., 734., 735., 736., 733., 734., 735., 736.,
      745., 746., 747., 748., 749., 750., 751., 752., 753., 754., 755., 756.,
      757., 758., 759., 760., 761., 762., 763., 764., 765., 766., 767., 768.,
      765., 766., 767., 768., 765., 766., 767., 768., 745., 746., 747., 748.,
      749., 750., 751., 752., 753., 754., 755., 756., 757., 758., 759., 760.,
      761., 762., 763., 764., 765., 766., 767., 768., 765., 766., 767., 768.,
      765., 766., 767., 768., 745., 746., 747., 748., 749., 750., 751., 752.,
      753., 754., 755., 756., 757., 758., 759., 760., 761., 762., 763., 764.,
      765., 766., 767., 768., 765., 766., 767., 768., 765., 766., 767., 768.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow5Stride1Forward, VALID3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 209., 210., 211., 212.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 401., 402., 403., 404., 405., 406., 407., 408.,
      409., 410., 411., 412., 413., 414., 415., 416., 433., 434., 435., 436.,
      437., 438., 439., 440., 441., 442., 443., 444., 445., 446., 447., 448.,
      465., 466., 467., 468., 469., 470., 471., 472., 473., 474., 475., 476.,
      477., 478., 479., 480., 497., 498., 499., 500., 501., 502., 503., 504.,
      505., 506., 507., 508., 509., 510., 511., 512., 657., 658., 659., 660.,
      661., 662., 663., 664., 665., 666., 667., 668., 669., 670., 671., 672.,
      689., 690., 691., 692., 693., 694., 695., 696., 697., 698., 699., 700.,
      701., 702., 703., 704., 721., 722., 723., 724., 725., 726., 727., 728.,
      729., 730., 731., 732., 733., 734., 735., 736., 753., 754., 755., 756.,
      757., 758., 759., 760., 761., 762., 763., 764., 765., 766., 767., 768.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
